// /*
//  * Tencent is pleased to support the open source community by making ovCompose available.
//  * Copyright (C) 2025 THL A29 Limited, a Tencent company. All rights reserved.
//  *
//  * Licensed under the Apache License, Version 2.0 (the "License");
//  * you may not use this file except in compliance with the License.
//  * You may obtain a copy of the License at
//  *
//  *      http://www.apache.org/licenses/LICENSE-2.0
//  *
//  * Unless required by applicable law or agreed to in writing, software
//  * distributed under the License is distributed on an "AS IS" BASIS,
//  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  * See the License for the specific language governing permissions and
//  * limitations under the License.
//  */

// @file:OptIn(ExperimentalForeignApi::class)

// package com.tencent.compose.utils

// import androidx.compose.ui.graphics.kLog
// import androidx.compose.ui.graphics.isDebugLogEnabled
// import androidx.compose.ui.napi.JsCallContext
// import androidx.compose.ui.napi.JsEnv
// import androidx.compose.ui.napi.JsEnv.createStringUtf8
// import androidx.compose.ui.napi.nApiValue
// import kotlinx.cinterop.COpaquePointer
// import kotlinx.cinterop.COpaquePointerVar
// import kotlinx.cinterop.ExperimentalForeignApi
// import kotlinx.cinterop.StableRef
// import kotlinx.cinterop.alloc
// import kotlinx.cinterop.allocArray
// import kotlinx.cinterop.asStableRef
// import kotlinx.cinterop.cValuesOf
// import kotlinx.cinterop.cstr
// import kotlinx.cinterop.get
// import kotlinx.cinterop.interpretCPointer
// import kotlinx.cinterop.memScoped
// import kotlinx.cinterop.objcPtr
// import kotlinx.cinterop.ptr
// import kotlinx.cinterop.rawValue
// import kotlinx.cinterop.staticCFunction
// import kotlinx.cinterop.toKString
// import kotlinx.cinterop.value
// import platform.ohos.napi_acquire_threadsafe_function
// import platform.ohos.napi_call_threadsafe_function
// import platform.ohos.napi_callback
// import platform.ohos.napi_callback_info
// import platform.ohos.napi_delete_reference
// import platform.ohos.napi_env
// import platform.ohos.napi_ok
// import platform.ohos.napi_ref
// import platform.ohos.napi_set_element
// import platform.ohos.napi_set_property
// import platform.ohos.napi_status
// import platform.ohos.napi_threadsafe_function
// import platform.ohos.napi_threadsafe_function_call_js
// import platform.ohos.napi_threadsafe_function_call_mode
// import platform.ohos.napi_value
// import platform.ohos.napi_valuetype
// import platform.napiwrapper.*
// import platform.ohos.napi_call_function
// import platform.ohos.napi_create_object
// import platform.ohos.napi_create_threadsafe_function
// import platform.ohos.napi_get_cb_info
// import platform.ohos.napi_get_global
// import platform.ohos.napi_threadsafe_functionVar
// import platform.ohos.napi_valueVar
// import platform.ohos.napi_wrap
// import platform.posix.size_tVar

// object KnEnv {

//     private var globalNApiEnv: napi_env? = null

//     fun init(env: napi_env) {
//         globalNApiEnv = env
//     }

//     fun env(): napi_env {
//         return JsEnv.env()
//     }

//     private fun checkStatus(status: napi_status): Boolean {
//         if (status != napi_ok) {
//             if (isDebugLogEnabled) {
//                 kLog("napi failed: $status")
//             }
//             return false
//         }
//         return true
//     }

//     fun getElement(obj: napi_value?, index: Int): napi_value? {
//         obj ?: return null
//         return interpretCPointer(Knapi_get_element(env().rawValue, obj.rawValue, index))
//     }

//     fun setElement(obj: napi_value?, index: Int, value: napi_value) {
//         obj ?: return
//         Knapi_set_element(env().rawValue, obj.rawValue, index, value.rawValue)
//     }

//     fun getArrayLength(array: napi_value?): Int {
//         array ?: return 0
//         return Knapi_get_array_length(env().rawValue, array.rawValue).toInt()
//     }

//     fun getAllPropertyNames(obj: napi_value?): napi_value? {
//         obj ?: return null
//         return interpretCPointer(Knapi_get_property_names(env().rawValue, obj.rawValue))
//     }

//     fun strictEquals(trgObject: napi_value?, srcObject: napi_value?): Boolean {
//         return Knapi_equals(env().rawValue, trgObject.rawValue, srcObject.rawValue)
//     }

//     fun getProperty(obj: napi_value?, key: napi_value?): napi_value? {
//         obj ?: return null
//         key ?: return null
//         return interpretCPointer(Knapi_get_property(env().rawValue, obj.rawValue, key.rawValue))
//     }

//     fun setProperty(obj: napi_value?, key: napi_value?, value: napi_value?) {
//         obj ?: return
//         key ?: return
//         Knapi_set_property(env().rawValue, obj.rawValue, key.rawValue, value.rawValue)
//     }

//     fun getNamedProperty(obj: napi_value?, str: String): napi_value? {
//         obj ?: return null
//         return Knapi_get_named_property(env().rawValue, obj.rawValue,
//             createStringUtf16(str).rawValue).let { interpretCPointer(it) }
//     }

//     fun createObject(): napi_value? {
//         return interpretCPointer(Knapi_create_object(env().rawValue))
//     }

//     fun getReferenceValue(ref: napi_ref?): napi_value? {
//         ref ?: return null
//         return interpretCPointer(Knapi_get_reference_value(env().rawValue, ref.rawValue))
//     }

//     fun createReference(value: napi_value?): napi_ref? {
//         return interpretCPointer(Knapi_create_reference(env().rawValue, value.rawValue))
//     }

//     fun deleteReference(ref: napi_ref?) {
//         ref ?: return
//         Knapi_delete_reference(env().rawValue, ref.rawValue)
//     }

//     fun createFunction(name: String, cb: napi_callback?, data: COpaquePointer?): napi_value? {
//         return interpretCPointer(Knapi_create_function(env().rawValue, createStringUtf16(name).rawValue, cb.rawValue, data.rawValue))
//     }

//     fun callFunction(
//         receiver: napi_value?,
//         func: napi_value?,
//         vararg args: napi_value?
//     ): napi_value? {
//         func ?: return null
//         return memScoped {
//             val result = alloc<napi_valueVar>()
//             checkStatus(
//                 napi_call_function(
//                     env(),
//                     receiver,
//                     func,
//                     args.size.toULong(),
//                     cValuesOf(*args),
//                     result.ptr
//                 )
//             )
//             result.value
//         }
//     }

//     fun createStringUtf16(str: String): napi_value? {
//         return interpretCPointer(str.getNapiValue(env().rawValue))
// //        return memScoped {
// //            interpretCPointer(Knapi_string_to_napi(env().rawValue, str.cstr.ptr))
// //        }
//     }

//     fun createDouble(value: Double): napi_value? {
//         return interpretCPointer(Knapi_double_to_napi(env().rawValue, value))
//     }

//     fun createFloat(value: Float): napi_value? = createDouble(value.toDouble())

//     fun createObjectWithWrap(value: Any): napi_value? {
//         return memScoped {
//             val result = alloc<napi_valueVar>()
//             checkStatus(napi_create_object(env(), result.ptr))
//             val valueRef = StableRef.create(value)
//             checkStatus(
//                 napi_wrap(
//                     env(), result.value, valueRef.asCPointer(),
//                     staticCFunction { _: napi_env?, data: COpaquePointer?, _: COpaquePointer? ->
//                         if (data == null) return@staticCFunction
//                         data.asStableRef<Any>().dispose()
//                     },
//                     null, null
//                 )
//             )
//             result.value
//         }
//     }

//     fun getBoolean(value: Boolean): napi_value? {
//         return interpretCPointer(Knapi_boolean_to_napi(env().rawValue, value))
//     }

//     fun createInt32(value: Int): napi_value? {
//         return interpretCPointer(Knapi_int_to_napi(env().rawValue, value))
//     }

//     fun createInt64(value: Long): napi_value? {
//         return interpretCPointer(Knapi_long_to_napi(env().rawValue, value))
//     }

//     fun getValueInt32(value: napi_value?): Int? {
//         value ?: return null
//         return Knapi_to_int(env().rawValue, value.rawValue)
//     }

//     fun getValueInt32(value: napi_value?, default: Int): Int {
//         value ?: return default
//         return Knapi_to_int(env().rawValue, value.rawValue)
//     }

//     fun getValueInt64(value: napi_value?): Long? {
//         value ?: return null
//         return Knapi_to_long(env().rawValue, value.rawValue)
//     }

//     fun getValueInt64(value: napi_value?, default: Long): Long {
//         value ?: return default
//         return Knapi_to_long(env().rawValue, value.rawValue)
//     }

//     fun getValueDouble(value: napi_value?): Double? {
//         value ?: return null
//         return Knapi_to_double(env().rawValue, value.rawValue)
//     }

//     fun getValueFloat(value: napi_value?): Float? = getValueDouble(value)?.toFloat()

//     fun getValueStringUtf8(value: napi_value?): String? {
//         value ?: return null
//         return Knapi_to_string(env().rawValue, value.rawValue)?.toKString()
//     }

//     fun getValueBool(value: napi_value?): Boolean? {
//         value ?: return null
//         return Knapi_to_boolean(env().rawValue, value.rawValue)
//     }

//     fun getUndefined(): napi_value? {
//         return interpretCPointer(Knapi_get_undefined(env().rawValue))
//     }

//     fun isUndefined(value: napi_value?): Boolean =
//         getType(value) == napi_valuetype.napi_undefined

//     private fun getNull(): napi_value? {
//         return interpretCPointer(Knapi_get_null(env().rawValue))
//     }

//     fun getType(value: napi_value?): napi_valuetype {
//         val type = Knapi_typeof(env().rawValue, value.rawValue)
//         return napi_valuetype.byValue(type)
//     }

//     fun getCbInfo(callbackInfo: napi_callback_info?): JsCallContext {
//         return memScoped {
//             val argc = alloc<size_tVar>()
//             checkStatus(
//                 napi_get_cb_info(
//                     env(),
//                     callbackInfo,
//                     argc.ptr,
//                     null,
//                     null,
//                     null
//                 )
//             )

//             val length = argc.value.toInt()
//             val args = allocArray<napi_valueVar>(length)
//             val jsThis = alloc<napi_valueVar>()
//             val data = alloc<COpaquePointerVar>()

//             checkStatus(
//                 napi_get_cb_info(
//                     env(),
//                     callbackInfo,
//                     argc.ptr,
//                     args.getPointer(this),
//                     jsThis.ptr,
//                     data.ptr
//                 )
//             )

//             val arguments = ArrayList<napi_value?>()
//             for (i in 0..<length) {
//                 arguments.add(args[i])
//             }
//             JsCallContext(jsThis.value, arguments, data.value)
//         }
//     }

//     fun getGlobal(): napi_value? {
//         return memScoped {
//             val result = alloc<napi_valueVar>()
//             napi_get_global(env(), result.ptr)
//             result.value
//         }
//     }

//     fun createThreadsafeFunction(
//         workName: String,
//         callback: napi_threadsafe_function_call_js?
//     ): napi_threadsafe_function? {
//         return memScoped {
//             val jsWorkName = createStringUtf8(workName)
//             val result = alloc<napi_threadsafe_functionVar>()
//             napi_create_threadsafe_function(
//                 env(), 0.nApiValue(), null,
//                 jsWorkName?.getPointer(this),
//                 0UL, 1UL, null, null, null, callback, result.ptr
//             )
//             result.value
//         }
//     }

//     fun callThreadsafeFunction(function: napi_threadsafe_function?, data: COpaquePointer?) {
//         napi_acquire_threadsafe_function(function)
//         napi_call_threadsafe_function(
//             function, data, napi_threadsafe_function_call_mode.napi_tsfn_nonblocking
//         )
//     }

//     fun stringify(value: napi_value?): String? {
//         val global = getGlobal()
//         val json = getProperty(global, createStringUtf16("JSON"))
//         val stringifyFunc = getProperty(json, createStringUtf16("stringify"))
//         val result = callFunction(json, stringifyFunc, value)
//         return getValueStringUtf8(result)
//     }

//     fun printValue(value: napi_value?, key: String? = "") {
//         val type = getType(value)
//         when (type) {
//             napi_valuetype.napi_undefined -> kLog("JsEnv::printValue: $key is undefined")
//             napi_valuetype.napi_null -> kLog("JsEnv::printValue: $key is null")
//             napi_valuetype.napi_symbol -> kLog("JsEnv::printValue: $key is symbol")
//             napi_valuetype.napi_object -> kLog("JsEnv::printValue: $key is object")
//             napi_valuetype.napi_function -> kLog("JsEnv::printValue: $key is function")
//             napi_valuetype.napi_number -> kLog("JsEnv::printValue: $key is number")
//             napi_valuetype.napi_string -> kLog("JsEnv::printValue: $key is string")
//             napi_valuetype.napi_boolean -> kLog("JsEnv::printValue: $key is boolean")
//             napi_valuetype.napi_bigint -> kLog("JsEnv::printValue: $key is bigint")
//             napi_valuetype.napi_external -> kLog("JsEnv::printValue: $key is external")
//             null -> kLog("JsEnv::printValue: $key is null")
//             else -> {}
//         }
//     }
// }